package com.mtiiot.fstcpserver.redis;

import com.mtiiot.fstcpserver.base.BaseService;
import com.mtiiot.fscore.bean.MetadataInfo;
import com.mtiiot.fscore.bean.elasticsearch.metadata.RedisMetadata;
import com.mtiiot.fscore.inter1.RedisService1;
import com.mtiiot.fscore.utils.RequestType;
import com.mtiiot.fscore.utils.StringUtil;
import com.mtiiot.fstcpserver.utils.Constants;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.JedisCluster;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Created by Administrator on 16-8-19.
 */
public class RedisServiceImpl1 extends BaseService implements RedisService1{
    private static final Logger logger = LogManager.getLogger(RedisServiceImpl1.class);

//    @Autowired
//    private RedisShardBase redisShardBase;
    @Autowired
    private JedisCluster jedisCluster;

   /* @Autowired
    private RedisDao redisDao;*/
    /**
     * 新增或者修改缓存
     *
     * @param metadataInfo 元数据信息
     * @param redisKey
     * @param value
     */
    @Override
    public boolean saveOrUpdateCache(MetadataInfo metadataInfo, String redisKey, String value) {
        boolean result=false;
        try{
            checkMetadata(metadataInfo);//验证元数据
            if(StringUtil.isEmpty(redisKey)){
                throw new Exception("reidskey 不能为空!");
            }
            String r=jedisCluster.set(redisKey,value);
            result=!StringUtil.isEmpty(r);

            //元数据入队列
            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo, md, RequestType.INSERT.getName());
            md.setRedisKey(redisKey);
            md.setRedisType(Constants.REDISTYPE_STRING);
            metadataInQueue(Constants.TOPIC_METADATAINFO, Constants.TYPE_METADATA_REDIS, md);
            return result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","saveOrUpdateCache",ex,logger);
            return result;
        }
    }

    /**
     * 新增或者修改缓存(可以设置超时时间 单位为s)
     *
     * @param metadataInfo 元数据信息
     * @param redisKey
     * @param value
     * @param timeout
     */
    @Override
    public boolean saveOrUpdateCache(MetadataInfo metadataInfo, String redisKey, String value, int timeout) {
        boolean result=false;
        try{
            checkMetadata(metadataInfo);//验证元数据
            if(StringUtil.isEmpty(redisKey)){
                throw new Exception("reidskey 不能为空!");
            }
            String r=jedisCluster.set(redisKey,value);
            jedisCluster.expire(redisKey,timeout);
            result=!StringUtil.isEmpty(r);

            //元数据入队列
            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo,md,RequestType.INSERT.getName());
            md.setRedisKey(redisKey);
            md.setRedisType(Constants.REDISTYPE_STRING);
            md.setSetTimeOut(true);
            md.setSetTimeOutTime(new Date());
            md.setTimeout(timeout);
            metadataInQueue(Constants.TOPIC_METADATAINFO, Constants.TYPE_METADATA_REDIS, md);
            return result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","saveOrUpdateCacheOnTimeout",ex,logger);
            return result;
        }
    }

    /**
     * 获取缓存
     *
     * @param metadataInfo 元数据信息
     * @param redisKey
     * @return
     */
    @Override
    public String getCache(MetadataInfo metadataInfo, String redisKey) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.get(redisKey);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","getCache",ex,logger);
            return null;
        }
    }

    /**
     * 获取缓存同时重新设置timeout
     *
     * @param metadataInfo 元数据信息
     * @param redisKey
     * @param timeout
     * @return
     */
    @Override
    public String getCacheAndSetTimeout(MetadataInfo metadataInfo, String redisKey, int timeout) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            String value = jedisCluster.get(redisKey);
            if(StringUtil.isEmpty(value)){
                return null;
            }
            jedisCluster.expire(redisKey,timeout);
            return value;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","getCacheAndSetTimeout",ex,logger);
            return null;
        }
    }

    /**
     * 删除缓存
     *
     * @param metadataInfo 元数据信息
     * @param redisKey
     */
    @Override
    public boolean deleteCache(MetadataInfo metadataInfo, String redisKey) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            Long  l = jedisCluster.del(redisKey);
            if(l==null){
                return false;
            }
            return true;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","deleteCache",ex,logger);
            return false;
        }
    }

    /**
     * redis List类型操作
     *
     * @param metadataInfo 元数据信息
     * @param key
     * @param value
     * @return
     */
    @Override
    public Long lpush(MetadataInfo metadataInfo, String key, String value) {
        Long result=null;
        try{
            checkMetadata(metadataInfo);//验证元数据
                result=jedisCluster.lpush(key,value);

            //元数据入队列
            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo,md,RequestType.INSERT.getName());
            md.setRedisKey(key);
            md.setRedisType(Constants.REDISTYPE_LIST);
            metadataInQueue(Constants.TOPIC_METADATAINFO,Constants.TYPE_METADATA_REDIS,md);
            return  result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","lpush",ex,logger);
            return result;
        }
    }

    /**
     * redis List类型操作
     *
     * @param metadataInfo 元数据信息
     * @param key
     * @return
     */
    @Override
    public Long llen(MetadataInfo metadataInfo, String key) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.llen(key);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","llen",ex,logger);
            return null;
        }
    }

    /**
     * redis List类型操作
     *
     * @param metadataInfo 元数据信息
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public List<String> lrange(MetadataInfo metadataInfo, String key, long start, long end) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.lrange(key,start,end);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","lrange",ex,logger);
            return null;
        }
    }

    /**
     * redis List类型操作
     *
     * @param metadataInfo 元数据信息
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public String ltrim(MetadataInfo metadataInfo, String key, long start, long end) {
        try{
            return jedisCluster.ltrim(key,start,end);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","ltrim",ex,logger);
            return null;
        }
    }

    /**
     * redis List类型操作
     *
     * @param metadataInfo 元数据信息
     * @param key
     * @param count
     * @param value
     * @return
     */
    @Override
    public Long lrem(MetadataInfo metadataInfo, String key, long count, String value) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.lrem(key,count,value);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","lrem",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @return
     */
    @Override
    public String hget(MetadataInfo metadataInfo, String key, String field) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hget(key,field);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hget",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @return
     */
    @Override
    public Long hdel(MetadataInfo metadataInfo, String key, String... field) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hdel(key,field);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hdel",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @param value
     * @return
     */
    @Override
    public Long hincrBy(MetadataInfo metadataInfo, String key, String field, long value) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hincrBy(key,field,value);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hincrBy",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @return
     */
    @Override
    public Long hlen(MetadataInfo metadataInfo, String key) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hlen(key);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hlen",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @param value
     * @return
     */
    @Override
    public Long hset(MetadataInfo metadataInfo, String key, String field, String value) {
        Long result=null;
        try{
            checkMetadata(metadataInfo);//验证元数据
            result=jedisCluster.hset(key,field,value);

            //元数据入队列
            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo, md, RequestType.INSERT.getName());
            md.setRedisKey(key);
            md.setRedisType(Constants.REDISTYPE_HASH);
            metadataInQueue(Constants.TOPIC_METADATAINFO, Constants.TYPE_METADATA_REDIS, md);

            return result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hset",ex,logger);
            return result;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @param value
     * @return
     */
    @Override
    public Long hsetnx(MetadataInfo metadataInfo, String key, String field, String value) {
        Long result=null;
        try{
            checkMetadata(metadataInfo);//验证元数据
            result=jedisCluster.hsetnx(key, field, value);

            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo, md, RequestType.INSERT.getName());
            md.setRedisKey(key);
            md.setRedisType(Constants.REDISTYPE_HASH);
            metadataInQueue(Constants.TOPIC_METADATAINFO, Constants.TYPE_METADATA_REDIS, md);
            return result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hsetnx",ex,logger);
            return result;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param field
     * @return
     */
    @Override
    public Boolean hexists(MetadataInfo metadataInfo, String key, String field) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hexists(key, field);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hexists",ex,logger);
            return false;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @return
     */
    @Override
    public Map<String, String> hgetAll(MetadataInfo metadataInfo, String key) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hgetAll(key);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hgetAll",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @return
     */
    @Override
    public Set<String> hkeys(MetadataInfo metadataInfo, String key) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hkeys(key);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hkeys",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param fields
     * @return
     */
    @Override
    public List<String> hmget(MetadataInfo metadataInfo, String key, String... fields) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hmget(key, fields);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hmget",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @return
     */
    @Override
    public List<String> hvals(MetadataInfo metadataInfo, String key) {
        try{
            checkMetadata(metadataInfo);//验证元数据
            return jedisCluster.hvals(key);
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hvals",ex,logger);
            return null;
        }
    }

    /**
     * redis hash类型操作
     *
     * @param metadataInfo
     * @param key
     * @param hash
     * @return
     */
    @Override
    public String hmset(MetadataInfo metadataInfo, String key, Map<String, String> hash) {
        String result=null;
        try{
            checkMetadata(metadataInfo);//验证元数据
            result=jedisCluster.hmset(key, hash);

            //元数据入队列
            RedisMetadata md=new RedisMetadata();
            setMetadataBeanData(metadataInfo, md, RequestType.INSERT.getName());
            md.setRedisKey(key);
            md.setRedisType(Constants.REDISTYPE_HASH);
            metadataInQueue(Constants.TOPIC_METADATAINFO, Constants.TYPE_METADATA_REDIS, md);
            return result;
        }catch(Exception ex){
            //异常信息 元数据入reids队列
            handleException(Constants.MODULE_REDIS,"RedisServiceImpl1","hmset",ex,logger);
            return result;
        }
    }
}
